home *** CD-ROM | disk | FTP | other *** search
/ Champak 106 / Vol 106.iso / games / hulk.swf / scripts / com / markdavies / net / Preloader.as
Encoding:
Text File  |  2010-04-12  |  8.2 KB  |  275 lines
  1. package com.markdavies.net
  2. {
  3.    import com.markdavies.events.CustomEvent;
  4.    import flash.display.Loader;
  5.    import flash.display.LoaderInfo;
  6.    import flash.events.*;
  7.    import flash.media.Sound;
  8.    import flash.net.URLLoader;
  9.    import flash.net.URLRequest;
  10.    import flash.utils.Dictionary;
  11.    import flash.utils.Timer;
  12.    
  13.    public class Preloader extends EventDispatcher
  14.    {
  15.       
  16.       public static var LOADING:String = "loading";
  17.       
  18.       public static var LOADED:String = "loaded";
  19.       
  20.       public static var TYPE_ROOT:String = "root";
  21.       
  22.       public static var ERROR:String = "error";
  23.       
  24.       public static var EVENT_SITE_LOAD_ERROR:String = "loadError";
  25.       
  26.       public static var TYPE_SOUND:String = "sound";
  27.       
  28.       public static var TYPE_XML:String = "xml";
  29.       
  30.       public static var UNLOADED:String = "unloaded";
  31.       
  32.       public static var TYPE_LOADER:String = "loader";
  33.        
  34.       
  35.       public var timer:Timer;
  36.       
  37.       private var _dperc:Number = 0;
  38.       
  39.       private var _lperc:Number = 0;
  40.       
  41.       public var itemRefs:Dictionary;
  42.       
  43.       private var _isLoaded:Boolean = false;
  44.       
  45.       public var preloadItems:Dictionary;
  46.       
  47.       public function Preloader()
  48.       {
  49.          preloadItems = new Dictionary();
  50.          itemRefs = new Dictionary();
  51.          _isLoaded = false;
  52.          _lperc = 0;
  53.          _dperc = 0;
  54.          super();
  55.       }
  56.       
  57.       public function stopCheckPreload() : void
  58.       {
  59.          timer.removeEventListener(TimerEvent.TIMER,doPreload);
  60.          timer.stop();
  61.       }
  62.       
  63.       public function get percLoaded() : Number
  64.       {
  65.          return _lperc;
  66.       }
  67.       
  68.       public function addItem(param1:*, param2:String = null, param3:Boolean = false) : void
  69.       {
  70.          var _loc4_:URLLoader = null;
  71.          var _loc5_:Loader = null;
  72.          var _loc6_:Sound = null;
  73.          var _loc7_:URLRequest = null;
  74.          var _loc8_:String = null;
  75.          var _loc9_:String = null;
  76.          switch(typeof param1)
  77.          {
  78.             case "string":
  79.                _loc9_ = String(param1.substr(param1.lastIndexOf(".") + 1,3));
  80.                if(param1.lastIndexOf(".") == -1)
  81.                {
  82.                   return;
  83.                }
  84.                switch(_loc9_)
  85.                {
  86.                   case "xml":
  87.                      _loc8_ = Preloader.TYPE_XML;
  88.                      break;
  89.                   case "swf":
  90.                   case "jpg":
  91.                   case "jpeg":
  92.                   case "gif":
  93.                   case "png":
  94.                      _loc8_ = Preloader.TYPE_LOADER;
  95.                      break;
  96.                   case "mp3":
  97.                      _loc8_ = Preloader.TYPE_SOUND;
  98.                }
  99.                break;
  100.             default:
  101.                _loc8_ = Preloader.TYPE_ROOT;
  102.          }
  103.          switch(_loc8_)
  104.          {
  105.             case Preloader.TYPE_XML:
  106.                _loc4_ = new URLLoader();
  107.                _loc7_ = new URLRequest(param1);
  108.                _loc4_.addEventListener(IOErrorEvent.IO_ERROR,ioErrorHandler);
  109.                _loc4_.load(_loc7_);
  110.                preloadItems[param1] = {
  111.                   "loader":_loc4_,
  112.                   "status":Preloader.UNLOADED,
  113.                   "type":Preloader.TYPE_XML
  114.                };
  115.                break;
  116.             case Preloader.TYPE_LOADER:
  117.                _loc5_ = new Loader();
  118.                _loc7_ = new URLRequest(param1);
  119.                _loc5_.contentLoaderInfo.addEventListener(IOErrorEvent.IO_ERROR,ioErrorHandler);
  120.                _loc5_.load(_loc7_);
  121.                preloadItems[param1] = {
  122.                   "loader":_loc5_,
  123.                   "status":Preloader.UNLOADED,
  124.                   "type":Preloader.TYPE_LOADER
  125.                };
  126.                break;
  127.             case Preloader.TYPE_SOUND:
  128.                _loc6_ = new Sound();
  129.                _loc7_ = new URLRequest(param1);
  130.                preloadItems[param1] = {
  131.                   "loader":_loc6_,
  132.                   "status":Preloader.UNLOADED,
  133.                   "type":Preloader.TYPE_SOUND
  134.                };
  135.                _loc6_.addEventListener(IOErrorEvent.IO_ERROR,ioErrorHandler);
  136.                _loc6_.load(_loc7_);
  137.                break;
  138.             case Preloader.TYPE_ROOT:
  139.                preloadItems[param1] = {
  140.                   "loader":param1,
  141.                   "status":Preloader.UNLOADED,
  142.                   "type":Preloader.TYPE_ROOT
  143.                };
  144.                break;
  145.             default:
  146.                return;
  147.          }
  148.          preloadItems[param1].required = param3;
  149.          if(param2 != null)
  150.          {
  151.             itemRefs[param2] = preloadItems[param1];
  152.          }
  153.       }
  154.       
  155.       public function get isLoaded() : Boolean
  156.       {
  157.          return _isLoaded;
  158.       }
  159.       
  160.       private function doPreload(param1:Event) : void
  161.       {
  162.          var lb:int = 0;
  163.          var lt:int = 0;
  164.          var li:LoaderInfo = null;
  165.          var allb:Number = NaN;
  166.          var allt:Number = NaN;
  167.          var requiredFilesMissing:Boolean = false;
  168.          var key:Object = null;
  169.          var e:Event = param1;
  170.          lb = 0;
  171.          lt = 0;
  172.          allb = 0;
  173.          allt = 0;
  174.          requiredFilesMissing = false;
  175.          for(key in preloadItems)
  176.          {
  177.             switch(preloadItems[key].status)
  178.             {
  179.                case Preloader.ERROR:
  180.                case Preloader.LOADING:
  181.                case Preloader.UNLOADED:
  182.                   if(preloadItems[key].required == true)
  183.                   {
  184.                      requiredFilesMissing = true;
  185.                   }
  186.             }
  187.             if(preloadItems[key].status != Preloader.ERROR)
  188.             {
  189.                try
  190.                {
  191.                   preloadItems[key].loader.contentLoaderInfo;
  192.                   li = preloadItems[key].loader.contentLoaderInfo;
  193.                   lb = int(li.bytesLoaded);
  194.                   lt = int(li.bytesTotal);
  195.                }
  196.                catch(ce2:Error)
  197.                {
  198.                   try
  199.                   {
  200.                      lb = int(preloadItems[key].loader.bytesLoaded);
  201.                      lt = int(preloadItems[key].loader.bytesTotal);
  202.                   }
  203.                   catch(ce1:Error)
  204.                   {
  205.                      lb = int(preloadItems[key].loader.loaderInfo.bytesLoaded);
  206.                      lt = int(preloadItems[key].loader.loaderInfo.bytesTotal);
  207.                   }
  208.                }
  209.                if(lb >= lt && lb != 0)
  210.                {
  211.                   preloadItems[key].status = Preloader.LOADED;
  212.                }
  213.                allb += lb;
  214.                allt += lt;
  215.             }
  216.          }
  217.          _lperc = allb / allt;
  218.          if(_lperc > 1)
  219.          {
  220.             _lperc = 1;
  221.          }
  222.          _dperc = Math.floor(_lperc * 100);
  223.          if(_dperc == 100 && requiredFilesMissing != true)
  224.          {
  225.             onLoadHandler();
  226.             _isLoaded = true;
  227.          }
  228.       }
  229.       
  230.       public function startCheckPreload() : void
  231.       {
  232.          _isLoaded = false;
  233.          try
  234.          {
  235.             timer.running;
  236.          }
  237.          catch(e:TypeError)
  238.          {
  239.             timer = new Timer(100);
  240.          }
  241.          timer.addEventListener(TimerEvent.TIMER,doPreload);
  242.          timer.start();
  243.       }
  244.       
  245.       private function onLoadHandler() : void
  246.       {
  247.          stopCheckPreload();
  248.          dispatchEvent(new Event(Event.COMPLETE));
  249.       }
  250.       
  251.       private function ioErrorHandler(param1:Event) : void
  252.       {
  253.          var _loc2_:Object = null;
  254.          for(_loc2_ in preloadItems)
  255.          {
  256.             if(preloadItems[_loc2_].loader == param1.target)
  257.             {
  258.                preloadItems[_loc2_].status = Preloader.ERROR;
  259.                if(preloadItems[_loc2_].required == true)
  260.                {
  261.                   dispatchEvent(new CustomEvent(Preloader.EVENT_SITE_LOAD_ERROR));
  262.                   stopCheckPreload();
  263.                }
  264.                break;
  265.             }
  266.          }
  267.       }
  268.       
  269.       public function get percLoadedDisplay() : String
  270.       {
  271.          return _dperc.toString() + "%";
  272.       }
  273.    }
  274. }
  275.